/**
 * RPG核心系统接口定义
 * 定义各个模块的职责和交互方式
 */

import { Attribute_base, SkillType, TargetType, attackKey } from "../../../shared/face/enums";

// ==================== 基础接口 ====================

/**
 * 实体接口 - 所有游戏实体的基础接口
 */
export interface IEntity {
    /** 实体唯一标识 */
    id: string;
    
    /** 实体名称 */
    name: string;
    
    /** 实体类型 */
    type: 'player' | 'enemy' | 'npc';
    
    /** 是否存活 */
    isAlive(): boolean;
    
    /** 获取属性值 */
    getAttribute(key: Attribute_base): number;
    
    /** 设置属性值 */
    setAttribute(key: Attribute_base, value: number): void;
    
    /** 受到伤害 */
    takeDamage(amount: number, type: attackKey): number;
    
    /** 治疗 */
    heal(amount: number): number;
}

/**
 * 位置接口 - 实体在游戏世界中的位置
 */
export interface IPosition {
    /** X坐标 */
    x: number;
    
    /** Y坐标 */
    y: number;
    
    /** 地图ID */
    mapId: string;
}

// ==================== 战斗系统接口 ====================

/**
 * 战斗状态枚举
 */
export enum BattleState {
    /** 准备中 */
    PREPARING = 'preparing',
    /** 进行中 */
    IN_PROGRESS = 'in_progress',
    /** 已结束 */
    FINISHED = 'finished',
    /** 已暂停 */
    PAUSED = 'paused'
}

/**
 * 战斗参与者接口
 */
export interface IBattleParticipant extends IEntity {
    /** 所属阵营 */
    team: 'home' | 'away';
    
    /** 战斗状态 */
    battleState: {
        /** 当前生命值 */
        currentHp: number;
        /** 最大生命值 */
        maxHp: number;
        /** 护盾值 */
        shield: number;
        /** 是否死亡 */
        isDead: boolean;
    };
    
    /** 获取可用技能 */
    getAvailableSkills(): ISkill[];
    
    /** 选择目标 */
    selectTarget(opponents: IBattleParticipant[]): IBattleParticipant | null;
    
    /** 执行行动 */
    performAction(targets: IBattleParticipant[]): IBattleAction | null;
}

/**
 * 战斗行动接口
 */
export interface IBattleAction {
    /** 行动者 */
    actor: IBattleParticipant;
    
    /** 目标列表 */
    targets: IBattleParticipant[];
    
    /** 使用的技能 */
    skill: ISkill;
    
    /** 行动类型 */
    type: 'attack' | 'skill' | 'item' | 'defend';
    
    /** 执行行动 */
    execute(): IBattleActionResult;
}

/**
 * 战斗行动结果接口
 */
export interface IBattleActionResult {
    /** 是否成功 */
    success: boolean;
    
    /** 造成的伤害 */
    damage: number;
    
    /** 治疗量 */
    healing: number;
    
    /** 应用的效果 */
    effects: IEffect[];
    
    /** 行动日志 */
    log: string;
}

/**
 * 战斗引擎接口
 */
export interface IBattleEngine {
    /** 当前战斗状态 */
    state: BattleState;
    
    /** 参与者列表 */
    participants: IBattleParticipant[];
    
    /** 当前回合 */
    currentRound: number;
    
    /** 最大回合数 */
    maxRounds: number;
    
    /** 初始化战斗 */
    initialize(participants: IBattleParticipant[]): void;
    
    /** 开始战斗 */
    start(): void;
    
    /** 执行回合 */
    executeRound(): void;
    
    /** 结束战斗 */
    end(): IBattleResult;
    
    /** 检查战斗是否结束 */
    isBattleOver(): boolean;
    
    /** 获取获胜方 */
    getWinner(): 'home' | 'away' | null;
}

/**
 * 战斗结果接口
 */
export interface IBattleResult {
    /** 获胜方 */
    winner: 'home' | 'away' | 'draw';
    
    /** 战斗回合数 */
    rounds: number;
    
    /** 参与者状态 */
    participantStates: Map<string, IBattleParticipant>;
    
    /** 战斗日志 */
    battleLog: IBattleLogEntry[];
    
    /** 奖励 */
    rewards: IBattleReward[];
}

/**
 * 战斗日志条目接口
 */
export interface IBattleLogEntry {
    /** 回合数 */
    round: number;
    
    /** 行动者ID */
    actorId: string;
    
    /** 目标ID */
    targetId: string;
    
    /** 行动类型 */
    actionType: string;
    
    /** 行动描述 */
    description: string;
    
    /** 数值变化 */
    valueChange: number;
    
    /** 时间戳 */
    timestamp: number;
}

/**
 * 战斗奖励接口
 */
export interface IBattleReward {
    /** 奖励类型 */
    type: 'exp' | 'gold' | 'item' | 'skill';
    
    /** 奖励数值 */
    amount: number;
    
    /** 奖励描述 */
    description: string;
}

// ==================== 技能系统接口 ====================

/**
 * 技能接口
 */
export interface ISkill {
    /** 技能ID */
    id: string;
    
    /** 技能名称 */
    name: string;
    
    /** 技能描述 */
    description: string;
    
    /** 技能类型 */
    type: SkillType;
    
    /** 目标类型 */
    targetTypes: TargetType[];
    
    /** 冷却时间 */
    cooldown: number;
    
    /** 当前冷却 */
    currentCooldown: number;
    
    /** 技能等级 */
    level: number;
    
    /** 最大等级 */
    maxLevel: number;
    
    /** 技能经验 */
    exp: number;
    
    /** 使用次数 */
    useCount: number;
    
    /** 永久提升 */
    permanentBoosts: Map<string, number>;
    
    /** 检查是否可用 */
    isAvailable(): boolean;
    
    /** 使用技能 */
    use(caster: IBattleParticipant, targets: IBattleParticipant[]): ISkillResult;
    
    /** 升级技能 */
    upgrade(expGain: number): boolean;
    
    /** 获取技能描述（动态） */
    getDescription(): string;
    
    /** 计算技能效果 */
    calculateEffect(caster: IBattleParticipant, target: IBattleParticipant): number;
}

/**
 * 技能结果接口
 */
export interface ISkillResult {
    /** 是否成功 */
    success: boolean;
    
    /** 技能效果 */
    effects: IEffect[];
    
    /** 伤害值 */
    damage: number;
    
    /** 治疗量 */
    healing: number;
    
    /** 应用的状态 */
    buffs: IBuff[];
    
    /** 结果描述 */
    description: string;
}

/**
 * 技能引擎接口
 */
export interface ISkillEngine {
    /** 注册技能 */
    registerSkill(skill: ISkill): void;
    
    /** 获取技能 */
    getSkill(id: string): ISkill | null;
    
    /** 获取所有技能 */
    getAllSkills(): ISkill[];
    
    /** 使用技能 */
    useSkill(skillId: string, caster: IBattleParticipant, targets: IBattleParticipant[]): ISkillResult;
    
    /** 升级技能 */
    upgradeSkill(skillId: string, expGain: number): boolean;
    
    /** 学习技能 */
    learnSkill(skillId: string, entity: IBattleParticipant): boolean;
}

// ==================== 效果系统接口 ====================

/**
 * 效果类型枚举
 */
export enum EffectType {
    /** 伤害 */
    DAMAGE = 'damage',
    /** 治疗 */
    HEAL = 'heal',
    /** 属性修改 */
    ATTRIBUTE_MODIFY = 'attribute_modify',
    /** 状态效果 */
    STATUS_EFFECT = 'status_effect',
    /** 护盾 */
    SHIELD = 'shield'
}

/**
 * 效果接口
 */
export interface IEffect {
    /** 效果ID */
    id: string;
    
    /** 效果类型 */
    type: EffectType;
    
    /** 效果名称 */
    name: string;
    
    /** 效果描述 */
    description: string;
    
    /** 效果数值 */
    value: number;
    
    /** 持续时间 */
    duration: number;
    
    /** 剩余时间 */
    remainingDuration: number;
    
    /** 应用效果 */
    apply(target: IBattleParticipant): void;
    
    /** 移除效果 */
    remove(target: IBattleParticipant): void;
    
    /** 更新效果 */
    update(target: IBattleParticipant): void;
    
    /** 检查是否过期 */
    isExpired(): boolean;
}

/**
 * Buff接口
 */
export interface IBuff extends IEffect {
    /** 层数 */
    stackCount: number;
    
    /** 最大层数 */
    maxStacks: number;
    
    /** 增加层数 */
    addStack(): void;
    
    /** 移除层数 */
    removeStack(): void;
}

/**
 * 效果引擎接口
 */
export interface IEffectEngine {
    /** 注册效果 */
    registerEffect(effect: IEffect): void;
    
    /** 应用效果 */
    applyEffect(effect: IEffect, target: IBattleParticipant): void;
    
    /** 移除效果 */
    removeEffect(effectId: string, target: IBattleParticipant): void;
    
    /** 更新效果 */
    updateEffects(target: IBattleParticipant): void;
    
    /** 获取目标的所有效果 */
    getEffects(target: IBattleParticipant): IEffect[];
}

// ==================== 管理器接口 ====================

/**
 * 战斗管理器接口
 */
export interface IBattleManager {
    /** 创建战斗 */
    createBattle(participants: IBattleParticipant[]): IBattleEngine;
    
    /** 开始战斗 */
    startBattle(battle: IBattleEngine): IBattleResult;
    
    /** 暂停战斗 */
    pauseBattle(battle: IBattleEngine): void;
    
    /** 恢复战斗 */
    resumeBattle(battle: IBattleEngine): void;
    
    /** 结束战斗 */
    endBattle(battle: IBattleEngine): IBattleResult;
}

/**
 * 技能管理器接口
 */
export interface ISkillManager {
    /** 初始化技能系统 */
    initialize(): void;
    
    /** 加载技能配置 */
    loadSkills(): void;
    
    /** 获取技能 */
    getSkill(id: string): ISkill | null;
    
    /** 获取所有技能 */
    getAllSkills(): ISkill[];
    
    /** 创建技能 */
    createSkill(config: any): ISkill;
    
    /** 验证技能配置 */
    validateSkill(config: any): boolean;
}

/**
 * 效果管理器接口
 */
export interface IEffectManager {
    /** 初始化效果系统 */
    initialize(): void;
    
    /** 注册效果类型 */
    registerEffectType(type: EffectType, handler: any): void;
    
    /** 创建效果 */
    createEffect(config: any): IEffect;
    
    /** 应用效果 */
    applyEffect(effect: IEffect, target: IBattleParticipant): void;
    
    /** 移除效果 */
    removeEffect(effectId: string, target: IBattleParticipant): void;
}

// ==================== 事件系统接口 ====================

/**
 * 事件接口
 */
export interface IEvent {
    /** 事件类型 */
    type: string;
    
    /** 事件数据 */
    data: any;
    
    /** 时间戳 */
    timestamp: number;
}

/**
 * 事件监听器接口
 */
export interface IEventListener {
    /** 事件类型 */
    eventType: string;
    
    /** 处理事件 */
    handle(event: IEvent): void;
}

/**
 * 事件管理器接口
 */
export interface IEventManager {
    /** 注册事件监听器 */
    registerListener(listener: IEventListener): void;
    
    /** 移除事件监听器 */
    removeListener(listener: IEventListener): void;
    
    /** 触发事件 */
    emit(event: IEvent): void;
    
    /** 清空所有监听器 */
    clear(): void;
} 